home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 1.st / POGOSRC.ARC / STGFX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  7.8 KB  |  485 lines
  1.  
  2. #include <aline.h>
  3. #include <osbind.h>
  4. #include <stdio.h>
  5. #include "pogo.h"
  6. #include "neo.h"
  7.  
  8.  
  9. #define XMAX 320
  10. #define YMAX 200
  11. #define REPLACE 1
  12. #define XOR    2
  13.  
  14. /* handy macro to find out how much memory a raster line takes up */
  15. #define Mask_line(width) ((((width)+15)>>3)&0xfffe)
  16. #define Mask_block(width, height) (Mask_line(width)*(height))
  17. #define Raster_line(width) (((((width)+15)>>3)&0xfffe)<<2)
  18. #define Raster_block(width, height) (Raster_line(width)*(height))
  19.  
  20. extern struct aline *aline;
  21. extern WORD handle;
  22. extern WORD in_graphics;
  23. extern WORD *cscreen, *physcreen;
  24.  
  25. char gemctable[16] = 
  26.     {
  27.     0, 2, 3, 6, 4, 7, 5, 8, 9, 0xa, 0xb, 0xe, 0xc, 0xf, 0xd, 1,
  28.     };
  29.  
  30. WORD bitmasks[16] = {
  31.     0x8000, 0x4000, 0x2000, 0x1000,
  32.     0x800, 0x400, 0x200, 0x100,
  33.     0x80, 0x40, 0x20, 0x10,
  34.     0x8, 0x4, 0x2, 0x1,
  35.     };
  36.  
  37. wait_a_jiffy(jiff)
  38. WORD jiff;
  39. {
  40. while (--jiff >= 0)
  41.     Vsync();
  42. }
  43.  
  44. set_acolor(color)
  45. register WORD color;
  46. {
  47. register struct aline *a = aline;
  48.  
  49. if (color & (1<<3) )
  50.     a->colbit3 = 1;
  51. else
  52.     a->colbit3 = 0;
  53. if (color & (1<<2) )
  54.     a->colbit2 = 1;
  55. else
  56.     a->colbit2 = 0;
  57. if (color & (1<<1) )
  58.     a->colbit1 = 1;
  59. else
  60.     a->colbit1 = 0;
  61. if (color & 1)
  62.     a->colbit0 = 1;
  63. else
  64.     a->colbit0 = 0;
  65. }
  66.  
  67. extern WORD screen_bounds[];
  68.  
  69. floodfill(x, y, color)
  70. int x, y, color;
  71. {
  72. if (getdot(x, y) == color)    /* avoid taking a long time to do nothing */
  73.     return;    
  74. vsf_color(handle, gemctable[color]);
  75. vsf_interior(handle, 1 /* solid */ );
  76. vs_clip(handle, 1, screen_bounds);
  77. v_contourfill(handle, x, y, -1);
  78. }
  79.  
  80. polyfill( points, count, color)
  81. WORD *points;
  82. WORD count, color;
  83. {
  84. vsf_color(handle, gemctable[color]);
  85. vsf_interior(handle, 1 /* solid */ );
  86. v_fillarea(handle, count, points);
  87. }
  88.  
  89. colblock(color, x1, y1, x2, y2)
  90. WORD color;
  91. register WORD x1, y1, x2, y2;
  92. {
  93. register struct aline *a = aline;
  94. WORD swap;
  95.  
  96. if (x1 > x2)
  97.     {
  98.     swap = x2;
  99.     x2 = x1;
  100.     x1 = swap;
  101.     }
  102. if (y1 > y2)
  103.     {
  104.     swap = y2;
  105.     y2 = y1;
  106.     y1 = swap;
  107.     }
  108. if (y2 < 0 || y1 >= YMAX)
  109.     return;
  110. if (x2 < 0 || x1 >= XMAX)
  111.     return;
  112. if (y1 < 0)
  113.     y1 = 0;
  114. if (x1 < 0)
  115.     x1 = 0;
  116. if (x2 >= XMAX)
  117.     x2 = XMAX-1;
  118. if (y2 >= YMAX)
  119.     y2 = YMAX-1;
  120. blast_block(x1,y1,x2,y2,color);
  121. }
  122.  
  123.  
  124. colrop(color, x, y, width, height)
  125. int color, x, y, width, height;
  126. {
  127. register struct aline *a = aline;
  128.  
  129. colblock(color, x, y, x+width, y+height);
  130. }
  131.  
  132. get_cmap(cmap)
  133. register WORD *cmap;
  134. {
  135. register int i;
  136.  
  137. for (i=0; i<16; i++)
  138.     *cmap++ = Setcolor(i, -1);
  139. }
  140.  
  141. #define STCOLOR(r,g,b) (((r & 0xe0)<<3) + ((g & 0xe0)>>1) + ((b & 0xe0)>>5))
  142.  
  143. WORD screen_cmap[] = 
  144.     {
  145.     STCOLOR(0, 0, 0),
  146.     STCOLOR(128, 0, 1*64),
  147.     STCOLOR(128, 0, 2*64),
  148.     STCOLOR(128, 0, 3*64),
  149.     STCOLOR(128, 0, 4*64-1),
  150.     STCOLOR(128, 1*64, 255),
  151.     STCOLOR(128, 2*64, 255),
  152.     STCOLOR(128, 3*64, 255),
  153.     STCOLOR(128, 4*64-1, 255),
  154.     STCOLOR(0, 128, 1*64),
  155.     STCOLOR(0, 128, 2*64),
  156.     STCOLOR(0, 128, 3*64),
  157.     STCOLOR(0, 128, 4*64-1),
  158.     STCOLOR(128, 128, 1*64),
  159.     STCOLOR(128, 128, 2*64),
  160.     STCOLOR(128, 128, 3*64),
  161.     };
  162. WORD *sys_cmap = screen_cmap;
  163.  
  164. put_cmap(c)
  165. WORD *c;
  166. {
  167. copy_words(c,sys_cmap, 16);
  168. Setpallete(sys_cmap);    /* restore start-up colors */
  169. }
  170.  
  171. set_color(color, r, g, b)
  172. int color, r, g, b;
  173. {
  174. int c;
  175.  
  176. color &= 15;        /* mask to existing color */
  177. c = STCOLOR(r,g,b);
  178. sys_cmap[color] = c;
  179. Setcolor(color, c);
  180. }
  181.  
  182. flashred()
  183. {
  184. set_color(0,255,0,0);
  185. wait_a_jiffy(10);
  186. set_color(0,0,0,0);
  187. }
  188.  
  189.  
  190. #ifdef EISENSTIEN
  191. line(color, x1, y1, x2, y2)
  192. WORD color, x1, y1, x2, y2;
  193. {
  194. register struct aline *a = aline;
  195.  
  196. set_acolor(color);
  197. a->lnmask = 0xffff;
  198. a->wmode = REPLACE;  
  199. a->x1 = x1;
  200. a->y1 = y1;
  201. a->x2 = x2;
  202. a->y2 = y2;
  203. aaline();
  204. }
  205.  
  206. pline(p)
  207. register union pt_int *p;
  208. {
  209. register struct aline *a = aline;
  210.  
  211. if (!in_graphics)
  212.     to_graphics();
  213. set_acolor(p[-5].i);
  214. a->lnmask = 0xffff;
  215. a->wmode = REPLACE;  
  216. a->x1 = p[-4].i;
  217. a->y1 = p[-3].i;
  218. a->x2 = p[-2].i;
  219. a->y2 = p[-1].i;
  220. aaline();
  221. }
  222.  
  223. pline(p)
  224. register union pt_int *p;
  225. {
  226. if (!in_graphics)
  227.     to_graphics();
  228. line(p[-5].i&15, p[-4].i, p[-3].i, p[-2].i, p[-1].i);
  229. }
  230. #endif EISENSTIEN
  231.  
  232.  
  233. /* just to fool compiler into treating a pointer as a long */
  234. long 
  235. pt_to_long(pt)
  236. long pt;
  237. {
  238. return(pt);
  239. }
  240.  
  241. long
  242. compress_screen(s, d)
  243. register char *s;
  244. char *d;
  245. {
  246. int i, j;
  247. char ravel_buf[Mask_line(XMAX)];
  248. register char *dpt;
  249. extern char *pack();
  250.  
  251. #define Mask_line(width) ((((width)+15)>>3)&0xfffe)
  252.  
  253. i = YMAX;
  254. dpt = d;
  255. while (--i >= 0)
  256.     {
  257.     j = 4;
  258.     while (--j >= 0)
  259.         {
  260.         ravel_line(s, ravel_buf, Mask_line(XMAX) );
  261.         dpt = pack(ravel_buf, dpt, Mask_line(XMAX) );
  262.         if (pt_to_long(dpt) - pt_to_long(d) > 32000L)
  263.             return(0);
  264.         s += sizeof(WORD);
  265.         }
  266.     s += Raster_line(XMAX)-4*sizeof(WORD);
  267.     }
  268. return( pt_to_long(dpt) - pt_to_long(d) );
  269. }
  270.  
  271. clear_screen()
  272. {
  273. zero_screen(cscreen);
  274. }
  275.  
  276. WORD *sw_buf;
  277. WORD *swscreens[2];
  278. int swap_ix;
  279. int got_swap;
  280.  
  281. gtext(s, x, y, color)
  282. char *s;
  283. WORD x, y;
  284. WORD color;
  285. {
  286. vst_color(handle, gemctable[color]);
  287. vswr_mode(handle, 1);
  288. v_gtext(handle, x, y+7, s);
  289. }
  290.  
  291. pgtext(p)
  292. union pt_int *p;
  293. {
  294. gtext(p[-1].p, p[-3].i, p[-2].i, p[-4].i);
  295. }
  296.  
  297. pgnumber(p)
  298. union pt_int *p;
  299. {
  300. char buf[36];
  301. static char format[4] = "%xd";
  302.  
  303. format[1] = p[-2].i + '0';
  304. sprintf(buf, format, p[-1].i);
  305. gtext(buf, p[-4].i, p[-3].i, p[-5].i);
  306. }
  307.  
  308. #define SMAX 128
  309.  
  310. /* screen 0 is never used so isn't confused with false return.  Screen 1
  311.    is the physical ST screen */
  312.  
  313. WORD *screens[SMAX+2];
  314. WORD *cmaps[SMAX+2];
  315. int lscreen = 1;
  316.  
  317. pscreen()
  318. {
  319. return(1);
  320. }
  321.  
  322. palloc_screen()
  323. {
  324. WORD *ns, *nc;
  325. int i;
  326.  
  327. for (i=2; i<SMAX+2; i++)
  328.     {
  329.     if (screens[i] == NULL)
  330.         {
  331.         if ((ns = beg_mem(32000)) == NULL)
  332.             return(0);
  333.         if ((nc = beg_mem(32)) == NULL)
  334.             {
  335.             freemem(ns);
  336.             return(0);
  337.             }
  338.         screens[i] = ns;
  339.         cmaps[i] = nc;
  340.         return(i);
  341.         }
  342.     }
  343. return(0);
  344. }
  345.  
  346. check_screen(s,who,start)
  347. int s;
  348. char *who;
  349. int start;
  350. {
  351. char buf[60];
  352.  
  353. if (s >= start  && s < SMAX+2)
  354.     {
  355.     if (screens[s] != NULL)
  356.         {
  357.         return(1);
  358.         }
  359.     }
  360. sprintf(buf, "Screen %d doesn't exist in %s", s, who);
  361. runtime_err(buf);
  362. return(0);
  363. }
  364.  
  365. pfree_screen(p)
  366. union pt_int *p;
  367. {
  368. int s;
  369.  
  370. s = p[-1].i;
  371. if (check_screen(s, "FreeScreen",2))
  372.     {
  373.     gentle_free(cmaps[s]);
  374.     gentle_free(screens[s]);
  375.     screens[s] = NULL;
  376.     }
  377. }
  378.  
  379.  
  380. puse_screen(p)
  381. union pt_int *p;
  382. {
  383. int s;
  384.  
  385. s = p[-1].i;
  386. if (check_screen(s, "UseScreen",1))
  387.     {
  388.     lscreen = s;
  389.     cscreen = screens[s];
  390.     sys_cmap = cmaps[s];
  391.     }
  392. }
  393.  
  394. pcopy_screen(p)
  395. union pt_int *p;
  396. {
  397. int s, d;
  398.  
  399. if (!in_graphics)
  400.     to_graphics();
  401. s = p[-2].i;
  402. d = p[-1].i;
  403. if (check_screen(s, "CopyScreen",1) && check_screen(d,"CopyScreen",1))
  404.     {
  405.     copy_screen(screens[s], screens[d]);
  406.     copy_words(cmaps[s], cmaps[d], 16);
  407.     if (d == 1)
  408.         Setpallete(cmaps[d]);
  409.     }
  410. }
  411.  
  412.  
  413. pblit(p)
  414. union pt_int *p;
  415. {
  416. int s, d;
  417.  
  418. p -= 8;    /* so can access parameters without thinking backwards */
  419. s = p[2].i;
  420. d = p[5].i;
  421. if (check_screen(s, "Blit", 1) && check_screen(d,"Blit",1))
  422.     {
  423.     copy_blit(p[0].i, p[1].i, p[3].i, p[4].i, screens[s], 160,
  424.         p[6].i, p[7].i, screens[d], 160);
  425.     }
  426. }
  427.  
  428. ptblit(p)
  429. union pt_int *p;
  430. {
  431. pblit(p);
  432. }
  433.  
  434. #define ALLIGN    256
  435.  
  436. pre_swap()
  437. {
  438. to_graphics();
  439. if (!got_swap)
  440.     {
  441.     if ((sw_buf = Malloc(32000L + 256)) == NULL)
  442.         {
  443.         runtime_err("Not enough memory for double-buffering, damn.");
  444.         return(0);
  445.         }
  446.     screens[1] = swscreens[0] = cscreen;
  447.     swscreens[1] = (WORD *)(((long)sw_buf+ALLIGN) & 0xffffff00);
  448.     }
  449. Setscreen(swscreens[1], swscreens[0], -1);
  450. swap_ix = 0;
  451. cscreen = swscreens[1];
  452. got_swap = 1;
  453. return(1);
  454. }
  455.  
  456. swap()
  457. {
  458. if (!got_swap)
  459.     {
  460.     if (!pre_swap())
  461.         return;
  462.     }
  463. screens[1] = cscreen = swscreens[swap_ix];
  464. swap_ix = 1-swap_ix;
  465. Setscreen(cscreen, swscreens[swap_ix], -1);
  466. Vsync();
  467. }
  468.  
  469. de_swap()
  470. {
  471. if (got_swap)
  472.     {
  473.     Setscreen(physcreen, physcreen, -1);
  474.     Mfree(sw_buf);
  475.     cscreen = physcreen;
  476.     got_swap = 0;
  477.     }
  478. }
  479.  
  480. vsync()
  481. {
  482. Vsync();
  483. }
  484.  
  485.